home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Archives / GNU / GNUPLOTsrc.lha / term / grass.trm < prev    next >
Encoding:
Text File  |  1996-01-22  |  15.4 KB  |  597 lines

  1. /*
  2.  * GNUPLOT - grass.trm
  3.  * $Id: grass.trm,v
  4.  *-
  5.  * Copyright (C) 1992-1995. James Darrell McCauley
  6.  *
  7.  * Permission to use, copy, and distribute this software and its
  8.  * documentation for any purpose with or without fee is hereby granted,
  9.  * provided that the above copyright notice appear in all copies and
  10.  * that both that copyright notice and this permission notice appear
  11.  * in supporting documentation.
  12.  *
  13.  * Permission to modify the software is granted, but not the right to
  14.  * distribute the modified code.  Modifications are to be distributed
  15.  * as patches to released version.
  16.  *
  17.  * This software  is provided "as is" without express or implied warranty.
  18.  *
  19.  * This file is included by ../term.c.
  20.  *
  21.  * This terminal driver supports:
  22.  *  GRASS graphics driver
  23.  *
  24.  * AUTHOR
  25.  * James Darrell McCauley, PhD        http://soils.ecn.purdue.edu/~mccauley/
  26.  * Dept of Agricultural Engineering   mccauley@ecn.purdue.edu
  27.  * Purdue University                  tel: 317.494.1198 fax: 317.496.1115
  28.  *
  29.  * 05 Apr 1995 - cleaned up code by adding explicit function declarations.
  30.  *               compiles clean with 'gcc -Wall'
  31.  * 14 Apr 1995 - adapted for new layout, added font selection
  32.  *
  33.  * send your comments or suggestions to (grassp-list@moon.cecer.army.mil).
  34.  *
  35.  */
  36. #include <stdio.h>
  37. #include <string.h>
  38. /* #include "gis.h" */ /* this causes conflicts with things in term.c */
  39.  
  40. #ifndef GOT_DRIVER_H
  41. #include "driver.h"
  42. #endif
  43.  
  44. #ifdef TERM_REGISTER
  45. register_term(grass)
  46. #endif
  47.  
  48.  
  49. #ifdef TERM_PROTO
  50. TERM_PUBLIC void GRASS_move __P((unsigned int x, unsigned int y));
  51. TERM_PUBLIC void cont_abs __P((int x, int y));
  52. TERM_PUBLIC void GRASS_options __P((void));
  53. TERM_PUBLIC void GRASS_init __P((void));
  54. TERM_PUBLIC void GRASS_reset __P((void));
  55. TERM_PUBLIC void GRASS_graphics __P((void));
  56. TERM_PUBLIC void GRASS_text __P((void));
  57. TERM_PUBLIC void GRASS_vector __P((unsigned int x, unsigned int y));
  58. TERM_PUBLIC void GRASS_linetype __P((int lt));
  59. TERM_PUBLIC void GRASS_put_text __P((unsigned int x, unsigned int y, char *str));
  60. TERM_PUBLIC int GRASS_text_angle __P((int ang));
  61. TERM_PUBLIC int GRASS_justify_text __P((enum JUSTIFY mode));
  62. TERM_PUBLIC void GRASS_point __P((unsigned int x, unsigned int y, int point));
  63. static void draw_points_dot __P((int x, int y));
  64. static void draw_points_diamond __P((int x, int y));
  65. static void draw_points_box __P((int x, int y));
  66. static void draw_points_fbox __P((int x, int y));
  67. static void draw_points_itriangle __P((int x, int y));
  68. static void draw_points_fitriangle __P((int x, int y));
  69. static void draw_points_triangle __P((int x, int y));
  70. static void draw_points_ftriangle __P((int x, int y));
  71. static void draw_points_plus __P((int x, int y));
  72. static void draw_points_octo __P((int x, int y));
  73. static void draw_points_focto __P((int x, int y));
  74. static void draw_points_x __P((int x, int y));
  75. TERM_PUBLIC int GRASS_set_font __P((char *font));
  76. /* TERM_PUBLIC void GRASS_set_pointsize __P((double size)); */
  77. TERM_PUBLIC void GRASS_arrow __P((unsigned int sx, unsigned int sy, unsigned int ex, unsigned int ey, int head));
  78. #define GOT_GRASS_PROTO
  79. #endif /* TERM_PROTO */
  80.  
  81. #ifndef TERM_PROTO_ONLY
  82. #ifdef TERM_BODY
  83.  
  84. #define GRASS_XMAX 1000
  85. #define GRASS_YMAX 1000
  86. #define GRASS_VCHAR 5
  87. #define GRASS_HCHAR 5
  88. #define GRASS_VTIC 3
  89. #define GRASS_HTIC 3
  90.  
  91. #define PNT_SIZE 3
  92. #define TYPE_DOT  -1
  93. #define TYPE_X  0
  94. #define TYPE_PLUS   1
  95. #define TYPE_BOX    2
  96. #define TYPE_DIAMOND    3    /* need type 4 and 5 */
  97. #define TYPE_TRIANGLE 4
  98. #define TYPE_OCTO 5
  99. #define TYPE_ITRIANGLE 6
  100. #define TYPE_FBOX 7
  101. #define TYPE_FTRIANGLE 8
  102. #define TYPE_FITRIANGLE 9
  103. #define TYPE_FOCTO 10
  104.  
  105. static int R__curx, R__cury;
  106.  
  107. static int grass_yoffset;
  108. static int grass_xoffset;
  109. static int y_max;
  110. static int points_buf_x[PNT_SIZE*PNT_SIZE]; /* for filled point types */
  111. static int points_buf_y[PNT_SIZE*PNT_SIZE];
  112.  
  113. void GRASS_move (x, y)
  114.   unsigned int x, y;
  115. {
  116.   int R_move_abs ();
  117.   /* R_move_abs (grass_xoffset+x, grass_yoffset-y + y_max); */
  118.   R_move_abs (grass_xoffset+x, grass_yoffset-y);
  119. }
  120.  
  121. void cont_abs (x, y)
  122.   int x, y;
  123. {
  124.   int R_cont_abs ();
  125.   /* R_cont_abs (grass_xoffset+x, grass_xoffset-y + y_max); */
  126.   R_cont_abs (grass_xoffset+x, grass_yoffset-y);
  127. }
  128.  
  129. void GRASS_options ()
  130. {
  131.   options_null ();        /* no options to begin with */
  132. }
  133.  
  134. void GRASS_init ()
  135. {
  136.   /* char buff[128]; */
  137.   char window_name[64];
  138.   float size = 3.0;
  139.   /* int backcolor; */
  140.   int dots_per_line;
  141.   int top, b, l, r;
  142.   /* int textcolor; */
  143.   struct termentry *t = term;
  144.   int G_gisinit();
  145.   int R_open_driver();
  146.   int D_setup();
  147.   int D_get_cur_wind();
  148.   int G_fatal_error();
  149.   int D_set_cur_wind();
  150.   int D_get_screen_window();
  151.   int R_set_window();
  152.   int R_text_size();
  153.   int R_font();
  154.   int R_screen_top();
  155.   int R_screen_bot();
  156.   int D_erase_window();
  157.  
  158.   G_gisinit ("g.gnuplot");
  159.  
  160.   R_open_driver ();
  161.  
  162.   D_setup (0); 
  163.  
  164.   if (D_get_cur_wind (window_name))
  165.     G_fatal_error ("No current window");
  166.  
  167.   if (D_set_cur_wind (window_name))
  168.     G_fatal_error ("Current window not available");
  169.  
  170.   /* Set up the screen, conversions, and graphics */
  171.   D_get_screen_window (&top, &b, &l, &r);
  172.   /* D_set_overlay_mode (1); */
  173.  
  174.   /* Figure out where to put text */
  175.  
  176.   R_set_window (top, b, l, r);
  177.   t->xmax = r-l;
  178.   t->ymax = b-top;
  179.   grass_xoffset=l;
  180.   grass_yoffset=b;
  181.  
  182.   dots_per_line = (int) (size / 100.0 * (float) (t->ymax));
  183.   t->v_char = t->h_char = (int) (.8 * (float) dots_per_line);
  184.   R_text_size (t->h_char, t->v_char);
  185.   R_font("romans");
  186.  
  187.   t->v_tic = t->h_tic = 4;
  188.  
  189.   y_max = t->ymax; /* kludge? */
  190.  
  191.   R__curx = R_screen_top ();
  192.   R__cury = R_screen_bot () + grass_yoffset;
  193.  
  194.   D_erase_window();
  195. /*
  196. fprintf(stderr,"**********************************************\n");
  197. fprintf(stderr,"DIAGNOSTIC TERMINAL SETUP\n");
  198. fprintf(stderr,"top = %d\tb = %d\tl = %d\tr = %d\n", top,b,l,r);
  199. fprintf(stderr,"name = %s\n", t->name);
  200. fprintf(stderr,"description = %s\n", t->description);
  201. fprintf(stderr,"xmax = %d\t", (int)t->xmax);
  202. fprintf(stderr,"ymax = %d\n", (int)t->ymax);
  203. fprintf(stderr,"v_char = %d\t", (int)t->v_char);
  204. fprintf(stderr,"h_char = %d\n", (int)t->h_char);
  205. fprintf(stderr,"v_tic = %d\t", (int)t->v_tic);
  206. fprintf(stderr,"h_tic = %d\n", (int)t->h_tic);
  207. fprintf(stderr,"**********************************************\n\n");
  208. */
  209. }
  210.  
  211. void GRASS_reset ()
  212. {
  213.   int R_standard_color();
  214.   int D_translate_color();
  215.   int R_flush();
  216.   int R_stabilize();
  217.   int R_close_driver();
  218.  
  219.   R_standard_color (D_translate_color ("black"));
  220.   /* D_erase_window(); .* don't clear after g.gnuplot is finished */ 
  221.   R_flush ();
  222.   R_stabilize ();
  223.   R_close_driver ();
  224. }
  225.  
  226. void GRASS_graphics ()
  227. {
  228.   int D_erase_window();
  229.   int R_flush();
  230.   int R_stabilize();
  231.   int R_standard_color();
  232.   int D_translate_color();
  233.  
  234.   R_flush ();
  235.   R_stabilize ();
  236.   R_standard_color (D_translate_color ("black"));
  237.   D_erase_window();
  238.   return;
  239. }
  240.  
  241. void GRASS_text ()
  242. {
  243.   int R_flush ();
  244.   int R_stabilize ();
  245.  
  246.   R_flush ();
  247.   R_stabilize ();
  248.   return;            /* device can't be used as a terminal */
  249. }
  250.  
  251. void GRASS_vector (x, y)
  252.   unsigned int x, y;
  253. {
  254.   int R_flush ();
  255.   int R_stabilize ();
  256.  
  257.   cont_abs (x, y);
  258.   R_flush ();
  259.   R_stabilize ();
  260. }
  261.  
  262. void GRASS_linetype (lt)
  263.   int lt;
  264. {
  265.   int R_standard_color();
  266.   int D_translate_color();
  267.   int R_flush ();
  268.   int R_stabilize ();
  269.  
  270.   while (lt > 10) lt-=10;
  271.  
  272.   if (lt <= -2)
  273.     R_standard_color (D_translate_color ("gray"));
  274.   else if (lt == -1)
  275.     R_standard_color (D_translate_color ("white"));
  276.   else if (lt == 0)
  277.     R_standard_color (D_translate_color ("red"));
  278.   else if (lt == 1)
  279.     R_standard_color (D_translate_color ("green"));
  280.   else if (lt == 2)
  281.     R_standard_color (D_translate_color ("magenta"));
  282.   else if (lt == 3)
  283.     R_standard_color (D_translate_color ("brown"));
  284.   else if (lt == 4)
  285.     R_standard_color (D_translate_color ("orange"));
  286.   else if (lt == 5)
  287.     R_standard_color (D_translate_color ("yellow"));
  288.   else if (lt == 6)
  289.     R_standard_color (D_translate_color ("blue"));
  290.   else if (lt == 7)
  291.     R_standard_color (D_translate_color ("violet"));
  292.   else if (lt == 8) 
  293.     R_standard_color (D_translate_color ("indigo"));
  294.   else if (lt == 9)
  295.     R_standard_color (D_translate_color ("gray"));
  296.   else /* if (lt == 10) */
  297.     R_standard_color (D_translate_color ("white"));
  298.   R_flush ();
  299.   R_stabilize ();
  300.   return;
  301. }
  302.  
  303. /* originally /usr/grass4/src/display/d.label/cmd/label.c */
  304.  
  305. void GRASS_put_text (x, y, str)
  306.   unsigned int x, y;
  307.   char *str;
  308. {
  309.   int R_text();
  310.   int R_flush ();
  311.   int R_stabilize ();
  312.   if (strlen (str) == 0)
  313.     return;
  314.  
  315.   GRASS_move (x, y);
  316.   /* R_standard_color (D_translate_color ("white")); */
  317.   R_text (str);
  318.   R_flush ();
  319.   R_stabilize ();
  320. }
  321.  
  322. int GRASS_text_angle (ang)
  323. int ang;
  324. {
  325.   int R_text_rotation();
  326.  
  327.   R_text_rotation((float)ang);
  328.   return TRUE;            /* GRASS can (?) rotate text */
  329. }
  330.  
  331. int GRASS_justify_text (mode)
  332.   enum JUSTIFY mode;
  333. {
  334.   return (FALSE);        /* don't mess with this now */
  335. }
  336.  
  337.  
  338. void GRASS_point (x, y, point)
  339. unsigned int x,y;
  340. int point;
  341. {
  342.   switch (point)
  343.   {
  344.   case TYPE_DOT:
  345.     draw_points_dot (x, y);
  346.     break;
  347.   case TYPE_X:
  348.     draw_points_x (x, y);
  349.     break;
  350.   case TYPE_PLUS:
  351.     draw_points_plus (x, y);
  352.     break;
  353.   case TYPE_BOX:
  354.     draw_points_box (x, y);
  355.     break;
  356.   case TYPE_DIAMOND:
  357.     draw_points_diamond (x, y);
  358.     break;
  359.   case TYPE_TRIANGLE:
  360.     draw_points_triangle (x, y);
  361.     break;
  362.   case TYPE_OCTO:
  363.     draw_points_octo (x, y);
  364.     break;
  365.   case TYPE_ITRIANGLE:
  366.     draw_points_itriangle (x, y);
  367.     break;
  368.   case TYPE_FBOX:
  369.     draw_points_fbox (x, y);
  370.     break;
  371.   case TYPE_FTRIANGLE:
  372.     draw_points_ftriangle (x, y);
  373.     break;
  374.   case TYPE_FITRIANGLE:
  375.     draw_points_fitriangle (x, y);
  376.     break;
  377.   case TYPE_FOCTO:
  378.     draw_points_focto (x, y);
  379.     break;
  380.   }
  381. }
  382.  
  383. /* modified from /usr/grass4/src/display/d.points/cmd/main.c */
  384.  
  385. void draw_points_dot (x, y)
  386.   int x, y;
  387. {
  388.   GRASS_move (x, y);
  389.   cont_abs (x, y);
  390. }
  391.  
  392. void draw_points_diamond (x, y)
  393.   int x, y;
  394. {
  395.   GRASS_move (x, y + PNT_SIZE);
  396.   GRASS_vector (x + PNT_SIZE, y);
  397.   GRASS_vector (x, y - PNT_SIZE);
  398.   GRASS_vector (x - PNT_SIZE, y);
  399.   GRASS_vector (x, y + PNT_SIZE);
  400. }
  401.  
  402. void draw_points_box (x, y)
  403.   int x, y;
  404. {
  405.   GRASS_move (x - PNT_SIZE, y - PNT_SIZE);
  406.   GRASS_vector (x - PNT_SIZE, y + PNT_SIZE);
  407.   GRASS_vector (x + PNT_SIZE, y + PNT_SIZE);
  408.   GRASS_vector (x + PNT_SIZE, y - PNT_SIZE);
  409.   GRASS_vector (x - PNT_SIZE, y - PNT_SIZE);
  410. }
  411.  
  412. void draw_points_fbox (x, y)
  413.   int x, y;
  414. {
  415.   int R_polygon_abs();
  416.   points_buf_x[0] = grass_xoffset + x - PNT_SIZE; 
  417.   points_buf_y[0]= grass_yoffset - (y + PNT_SIZE);
  418.   points_buf_x[1] = grass_xoffset + x + PNT_SIZE; 
  419.   points_buf_y[1]= grass_yoffset - (y + PNT_SIZE);
  420.   points_buf_x[2] = grass_xoffset + x + PNT_SIZE; 
  421.   points_buf_y[2]= grass_yoffset - (y - PNT_SIZE);
  422.   points_buf_x[3] = grass_xoffset + x - PNT_SIZE; 
  423.   points_buf_y[3]= grass_yoffset - (y - PNT_SIZE);
  424.   R_polygon_abs(points_buf_x, points_buf_y, 4 );
  425. }
  426.  
  427. void draw_points_itriangle (x, y)
  428.   int x, y;
  429. {
  430.   GRASS_move (x - PNT_SIZE, y + PNT_SIZE);
  431.   GRASS_vector (x + PNT_SIZE, y + PNT_SIZE);
  432.   GRASS_vector (x , y - PNT_SIZE);
  433.   GRASS_vector (x - PNT_SIZE, y + PNT_SIZE);
  434. }
  435.  
  436. void draw_points_fitriangle (x, y)
  437.   int x, y;
  438. {
  439.   int R_polygon_abs();
  440.  
  441.   points_buf_x[0] = grass_xoffset + x + PNT_SIZE; 
  442.   points_buf_y[0] = grass_yoffset - (y + PNT_SIZE);
  443.   points_buf_x[1] = grass_xoffset + x ;           
  444.   points_buf_y[1] = grass_yoffset - (y - PNT_SIZE);
  445.   points_buf_x[2] = grass_xoffset + x - PNT_SIZE; 
  446.   points_buf_y[2] = grass_yoffset - (y + PNT_SIZE);
  447.   R_polygon_abs(points_buf_x, points_buf_y, 3 );
  448. }
  449.  
  450. void draw_points_triangle (x, y)
  451.   int x, y;
  452. {
  453.   GRASS_move (x - PNT_SIZE, y - PNT_SIZE);
  454.   GRASS_vector (x , y + PNT_SIZE);
  455.   GRASS_vector (x + PNT_SIZE, y - PNT_SIZE);
  456.   GRASS_vector (x - PNT_SIZE, y - PNT_SIZE);
  457. }
  458.  
  459. void draw_points_ftriangle (x, y)
  460.   int x, y;
  461. {
  462.   int R_polygon_abs();
  463.  
  464.   points_buf_x[0] = grass_xoffset + x;            
  465.   points_buf_y[0]= grass_yoffset - (y + PNT_SIZE);
  466.   points_buf_x[1] = grass_xoffset + x + PNT_SIZE; 
  467.   points_buf_y[1]= grass_yoffset - (y - PNT_SIZE);
  468.   points_buf_x[2] = grass_xoffset + x - PNT_SIZE; 
  469.   points_buf_y[2]= grass_yoffset - (y - PNT_SIZE);
  470.   R_polygon_abs(points_buf_x, points_buf_y, 3 );
  471. }
  472.  
  473. void draw_points_plus (x, y)
  474.   int x, y;
  475. {
  476.   GRASS_move (x - PNT_SIZE, y);
  477.   GRASS_vector (x + PNT_SIZE, y);
  478.   GRASS_move (x, y - PNT_SIZE);
  479.   GRASS_vector (x, y + PNT_SIZE);
  480. }
  481.  
  482. /* depends on PNT_SIZE */
  483. void draw_points_octo (x, y)
  484.   int x, y;
  485. {
  486.   /* CCW */
  487.   GRASS_move (x - (int) (PNT_SIZE/3), y - PNT_SIZE);   /* 1 */
  488.   GRASS_vector (x + (int) (PNT_SIZE/3), y - PNT_SIZE); /* 2 */
  489.   GRASS_vector (x + PNT_SIZE, y - (int) (PNT_SIZE/3)); /* 3 */
  490.   GRASS_vector (x + PNT_SIZE, y + (int) (PNT_SIZE/3)); /* 4 */
  491.   GRASS_vector (x + (int) (PNT_SIZE/3), y + PNT_SIZE); /* 5 */
  492.   GRASS_vector (x - (int) (PNT_SIZE/3), y + PNT_SIZE); /* 6 */
  493.   GRASS_vector (x - PNT_SIZE, y + (int) (PNT_SIZE/3)); /* 7 */
  494.   GRASS_vector (x - PNT_SIZE, y - (int) (PNT_SIZE/3)); /* 8 */
  495.   GRASS_vector (x - (int) (PNT_SIZE/3), y - PNT_SIZE); /* 1 */
  496. }
  497.  
  498. /* depends on PNT_SIZE */
  499. void draw_points_focto (x, y)
  500.   int x, y;
  501. {
  502.   int R_polygon_abs();
  503.  
  504.   /* CCW */
  505.   points_buf_x[0] = grass_xoffset + x + (int) (PNT_SIZE/3);
  506.   points_buf_y[0] = grass_yoffset - (y - PNT_SIZE); 
  507.   points_buf_x[1] = grass_xoffset + x + PNT_SIZE;
  508.   points_buf_y[1] = grass_yoffset - (y - (int) (PNT_SIZE/3)); 
  509.   points_buf_x[2] = grass_xoffset + x + PNT_SIZE;
  510.   points_buf_y[2] = grass_yoffset - (y + (int) (PNT_SIZE/3));
  511.   points_buf_x[3] = grass_xoffset + x + (int) (PNT_SIZE/3);
  512.   points_buf_y[3] = grass_yoffset - (y + PNT_SIZE); 
  513.   points_buf_x[4] = grass_xoffset + x - (int) (PNT_SIZE/3);
  514.   points_buf_y[4] = grass_yoffset - (y + PNT_SIZE);
  515.   points_buf_x[5] = grass_xoffset + x - PNT_SIZE;
  516.   points_buf_y[5] = grass_yoffset - (y + (int) (PNT_SIZE/3)); 
  517.   points_buf_x[6] = grass_xoffset + x - PNT_SIZE;
  518.   points_buf_y[6] = grass_yoffset - (y - (int) (PNT_SIZE/3));
  519.   points_buf_x[7] = grass_xoffset + x - (int) (PNT_SIZE/3);
  520.   points_buf_y[7] = grass_yoffset - (y - PNT_SIZE); 
  521.   R_polygon_abs(points_buf_x, points_buf_y, 8 );
  522. }
  523.  
  524. void draw_points_x (x, y)
  525. int x,y;
  526. {
  527.   GRASS_move (x - PNT_SIZE, y - PNT_SIZE);
  528.   GRASS_vector (x + PNT_SIZE, y + PNT_SIZE);
  529.   GRASS_move (x + PNT_SIZE, y - PNT_SIZE);
  530.   GRASS_vector (x - PNT_SIZE, y + PNT_SIZE);
  531. }
  532.  
  533. int GRASS_set_font (font)
  534. char *font;
  535. {
  536.   char name[32];
  537.   int size,sep, R_font();
  538.   struct termentry *t = term;
  539.   int R_text_size (), dots_per_line;
  540.  
  541.   /* G_warning(font); */
  542.  
  543.   sep=strcspn(font,",");
  544.   strncpy(name,font,sep); name[sep]='\0';
  545.   sscanf (&(font[sep+1]),"%d",&size);
  546.  
  547.   if (size==0)
  548.     size=3;
  549.   dots_per_line = (int) (size / 100.0 * (float) (t->ymax));
  550.   t->v_char = t->h_char = (int) (.8 * (float) dots_per_line);
  551.   R_text_size (t->h_char, t->v_char);
  552. /* cyrilc,gothgbt,gothgrt,gothitt,greekc,greekcs,greekp,
  553. greeks,italicc,italiccs,italict,romanc,romancs,romand,
  554. romans,romant,scriptc,scripts */
  555.  
  556.   if (strlen(name) > 5 ) 
  557.     R_font(name);
  558.   else
  559.     R_font("romans");
  560.   return TRUE;
  561. }
  562.  
  563. #ifdef GRASS_POINTSIZE
  564. void GRASS_set_pointsize (size));
  565. double *size;
  566. {
  567.   return;
  568. }
  569. #endif /* GRASS_POINTSIZE */
  570.  
  571. /* need to fix */
  572. void GRASS_arrow (sx, sy, ex, ey, head)
  573.   unsigned int sx, sy, ex, ey; 
  574.   int head;
  575. {
  576.   do_arrow (sx, sy, ex, ey, 1);
  577.   return;
  578. }
  579.  
  580. #endif /* TERM_BODY */
  581.  
  582. #ifdef TERM_TABLE
  583. TERM_TABLE_START(grass_driver)
  584.     "grass", "GRASS Graphics Monitor",
  585.     GRASS_XMAX, GRASS_YMAX, GRASS_VCHAR, GRASS_HCHAR,
  586.     GRASS_VTIC, GRASS_HTIC, GRASS_options, GRASS_init, GRASS_reset,
  587.     GRASS_text, null_scale, GRASS_graphics, GRASS_move, GRASS_vector,
  588.     GRASS_linetype, GRASS_put_text, GRASS_text_angle,
  589.     GRASS_justify_text, GRASS_point, GRASS_arrow, GRASS_set_font
  590. TERM_TABLE_END(grass_driver)
  591.  
  592.  
  593. #undef LAST_TERM
  594. #define LAST_TERM grass_driver
  595. #endif /* TERM_TABLE */
  596. #endif /* TERM_PROTO_ONLY */
  597.